import { commonStore } from '@/common/store/modules/common'
import { cacheJson, CacheType } from '@/common/apis/cache'
import commonAction from './http'
export default {
  $getCache: (
    type: CacheType, // type: 要取的缓存类型，此type会控制缓存的数据和缓存的请求地址
    hasObj?: string, // hasObj 是否需要转换成_id为key的数据
    isTree?: string, // isTree是否处理树形结构
    formServer?: string, // formServer: 是否重新请求
    hideLoading?: string, // hideLoading: 是否展示遮罩, 默认有遮罩
    data?: any, // data: 请求参数
    key?: string // 保存对象的key
  ) => {
    let newTypes: any[] = [] // vuex中存在，不需要再次请求
    let resData: any = []
    const publicCache: any = commonStore().publicCache
    if (formServer) {
      // 全部从服务端获取最新的数据
      newTypes = [type]
    } else {
      // 过滤，vuex不存在的，才请求服务端数据
      const existArr = publicCache[type] && Array.isArray(publicCache[type]) && publicCache[type].length > 0 // 缓存的为数组
      const exsitObj =
        publicCache[type] && publicCache[type].constructor === Object && Object.keys(publicCache[type]).length > 0 // 缓存的为对象
      if (existArr || exsitObj) {
        // vuex中有
        resData = publicCache[type]
      } else {
        // vuex中不存在，请求服务端数据
        newTypes.push(type)
      }
    }
    if (newTypes.length > 0) {
      // 有需要重新发请求的类型
      const actionData = {
        url: cacheJson[type], // 从缓存的映射表中获取请求地址
        method: 'GET',
        data: data || {},
        hideLoading: hideLoading ? true : false
      }
      return commonAction(actionData)
        .then((resp: any) => {
          if (resp && resp.success) {
            const lastData = resp.data || []
            commonStore().setPublicCache({ data: lastData, type, hasObj, isTree, key })
            return lastData
          } else {
            return resData // 直接返回vuex中的数据
          }
        })
        .catch((err: any) => {
          console.log(err)
          return resData // 直接返回vuex中的数据
        })
    } else {
      return new Promise((resolve) => {
        // 直接返回vuex中的数据
        resolve(resData)
      })
    }
  },
  // 更新指定的缓存(更新整个data对象替换)， type:单个缓存的类型, data:要更新的对象， key: 用来匹配的key, 比如: _id, hasObj 是否需要转换成_id为key的数据
  $updateCache: (type: CacheType, data: any, key: string, hasObj: string) => {
    const publicCache: any = commonStore().publicCache
    const currentArr = publicCache[type] || []
    const newArr: any[] = []
    if (currentArr && currentArr.length > 0) {
      // 找到指定的数据对象
      currentArr.forEach((item: any) => {
        item[key] === data[key] ? newArr.push(data) : newArr.push(item) // 标识key相等，更新数据
      })
      commonStore().setPublicCache({ data: newArr, type, hasObj, key }) // hasObj会把对应的key obj的数据也同时更新
    }
  },
  // 更新指定的缓存（只替换某个字段eg: 停用/启用）， type:单个缓存的类型, replaceData: { _id: 'xxxx',key: 'status', value: 'enable'}, replaceKey: 用来匹配的key, 比如: _id,  hasObj 是否需要转换成_id为key的数据
  $updateCacheBySingleKey: (type: CacheType, replaceData: any, replaceKey: string, hasObj: string) => {
    const publicCache: any = commonStore().publicCache
    const currentArr = publicCache[type] || []
    const newArr: any[] = []
    if (currentArr && currentArr.length > 0) {
      // 找到指定的数据对象
      currentArr.forEach((item: any) => {
        if (
          item[replaceKey] === replaceData[replaceKey] &&
          (item[replaceData.key] || Boolean(item[replaceData.key]) === false)
        ) {
          item[replaceData.key] = replaceData.value
        }
        newArr.push(item)
      })
      commonStore().setPublicCache({ data: newArr, type, hasObj, key: replaceKey }) // hasObj会把对应的key obj的数据也同时更新
    }
  },
  // 往缓存中新加数据，type:单个缓存的类型,data: 要添加的对象， hasObj 是否需要转换成_id为key的数据, key: hasObj后对象的key
  $addOneCache: (type: CacheType, data: any, hasObj: string, key?: string) => {
    const publicCache: any = commonStore().publicCache
    const currentArr = publicCache[type] || []
    if (currentArr.length <= 0) {
      // 没有相关缓存，让用的地方自己发请求拉最新数据（否则会导致当前新加了数据，使用的模块不发请求）
      return false
    }
    currentArr.push(data)
    commonStore().setPublicCache({ data: currentArr, type, hasObj, key }) // hasObj会把对应的key obj的数据也同时更新
  },
  // 删除某条数据，type:单个缓存的类型,key: 用来匹配的key, 比如: _id, value: key对应的值，hasObj 是否需要转换成_id为key的数据
  $deleteCache: (type: CacheType, key: string, value: string, hasObj: string) => {
    const publicCache: any = commonStore().publicCache
    const currentArr = publicCache[type] || []
    const newArr: any[] = []
    if (currentArr && currentArr.length > 0) {
      // 找到指定的数据对象
      currentArr.forEach((item: any) => {
        if (item[key] !== value) {
          // 标识key相等，更新数据
          newArr.push(item)
        }
      })
      commonStore().setPublicCache({ data: newArr, type, hasObj, key }) // hasObj会把对应的key obj的数据也同时更新
    }
  }
}
